#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    // OpenSerialPorts("com3");
    // refreshSerialPorts();
    openSavedPort();
    connect(ui->BaudRate, &QLineEdit::editingFinished, this, &MainWindow::SetBaudRate);
    // connect(ui->RSSI, &QLineEdit::editingFinished, this, &MainWindow::on_RSSI_returnPressed);
    DefaultPattern();
    // 设置背景图片
    // QPixmap bkgnd(":/Users/10007754/Desktop/Works/gitee/Remotecontrol/Remotecontrol/images/background.jpg");
    // bkgnd = bkgnd.scaled(this->size(), Qt::IgnoreAspectRatio);
    // QPalette palette;
    // palette.setBrush(QPalette::Window, bkgnd);
    // this->setPalette(palette);


    on_RSSI_returnPressed();
    SetBaudRate();


    timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, &MainWindow::handleTimeout);
    connect(this, &MainWindow::returnToReadData, this, &MainWindow::readData);



}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::handleTimeout()
{
        // qDebug() << "超时错误";
        // ui->label->setText("时间到，若存在红色则为不通过");

        // timer->stop();
        // Within20s = false;
        // entertest = false;
        isGrey = true;
        data.clear();
        temp=false;
        qDebug() << "时间到";
        ui->label->setText("时间到");
        // Lighting->setStyleSheet("background-color: grey");
        // Lighting->setStyleSheet("background-color: grey; border-radius: 42px;");
        timer->stop();
        readData();

}
// 从配置文件中读取保存的串口信息，并打开该串口
void MainWindow::openSavedPort()
{
    QSettings settings("MyCompany", "MyApp");
    lastSelectedPort = settings.value("lastSelectedPort").toString();
    // 从配置文件中读取 SaveRSSI 和 SaveBaudRate 的值
    SaveRSSI = settings.value("SaveRSSI").toString();
    SaveBaudRate = settings.value("SaveBaudRate").toInt();
    qDebug() << "lastSelectedPort:"<<lastSelectedPort;
    if (!lastSelectedPort.isEmpty())
    {
        OpenSerialPorts(lastSelectedPort); // 使用保存的串口信息直接打开串口
        ui->comboBox->addItem(lastSelectedPort);
        availableports();
        qDebug() << "Opening saved port: " << lastSelectedPort;

    }
    else
    {
        refreshSerialPorts();
        qDebug() << "No saved port available.";
    }

}
void MainWindow::closeEvent(QCloseEvent *event)
{
    QSettings settings("MyCompany", "MyApp");
    settings.setValue("SaveRSSI", SaveRSSI);
    settings.setValue("SaveBaudRate", SaveBaudRate);
    settings.setValue("lastSelectedPort", lastSelectedPort);
    QMainWindow::closeEvent(event);
}

//打开串口
void MainWindow::OpenSerialPorts(const QString &portName)
{
    if(SaveBaudRate==0||SaveBaudRate== NULL)SaveBaudRate=QSerialPort::Baud115200;
    qDebug() << "SaveBaudRate"<<SaveBaudRate ;

    m_serial.setPortName(portName);//获取当前串口名
    //打开
    m_serial.open(QIODevice::ReadWrite);//读写模式
    if(m_serial.isOpen())
    {
        qDebug() << "打开成功 "<<portName ;
    ui->label->setText("打开成功");
    m_serial.setBaudRate(SaveBaudRate);//115200
    m_serial.setDataBits(QSerialPort::Data8); //数据位
    m_serial.setStopBits(QSerialPort::OneStop);//停止位
    lastSelectedPort=portName;                //将打开的串口信息记录
    QObject::connect(&m_serial, &QSerialPort::readyRead, this, &MainWindow::readData); //开始接收串口数据
    }
    else
    {
    qDebug() << "打开失败" ;
    ui->label->setText("打开失败");
}
}
// 获取可用的串口信息
void MainWindow::availableports()
{
    // 获取可用的串口信息
    QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();

    // 遍历可用串口，将其添加到comboBox中（确保不重复添加）
    foreach(const QSerialPortInfo &portInfo, ports)
    {
        // 获取串口名字
        QString portName = portInfo.portName();

        // 检查该串口是否已经存在于comboBox中
        bool alreadyAdded = false;
        for (int i = 0; i < ui->comboBox->count(); ++i)
        {
            if (ui->comboBox->itemText(i) == portName)
            {
                alreadyAdded = true;
                break;
            }
        }
        // 如果该串口不存在于comboBox中，则添加
        if (!alreadyAdded)
        {
            ui->comboBox->addItem(portName);
        }
    }
}
//获取串口信息 添加到comboBox中
void MainWindow::refreshSerialPorts()
{
    // 清空comboBox中的项
    ui->comboBox->clear();
    availableports();
    on_comboBox_activated();
}

void MainWindow::SetBaudRate() {
    if(SaveBaudRate == 0) {
        SaveBaudRate = 115200;
        ui->BaudRate->setPlaceholderText("波特率:115200");
    } else {
        QString baudRateStr = QString::number(SaveBaudRate);
        ui->BaudRate->setPlaceholderText(QString("波特率 %1").arg(baudRateStr));
    }

    inputBaudRate = ui->BaudRate->text().toInt();
    if(inputBaudRate != 0) {
        SaveBaudRate = inputBaudRate;
    }
    qDebug() << "波特率设置为:" << SaveBaudRate;
}

void MainWindow::RightComp(QFrame* frame )
{
    frame->setFixedSize(300, 300);
    frame->setStyleSheet("background-color: green; border-radius: 150px;");
}

void MainWindow::ErrorComp(QFrame* frame)
{
    frame->setFixedSize(300, 300);
    frame->setStyleSheet("background-color: red; border-radius: 150px;");
    // frame->setStyleSheet("background-color: red;");
}
void MainWindow::NumRightComp(QFrame* frame )
{
    frame->setFixedSize(SECTOR_SIZE, SECTOR_SIZE);
    frame->setStyleSheet("background-color: green; border-radius: 25px;");
}
void MainWindow::NumErrorComp(QFrame* frame)
{
    frame->setFixedSize(SECTOR_SIZE, SECTOR_SIZE);
    frame->setStyleSheet("background-color: red; border-radius: 25px;");
    // frame->setStyleSheet("background-color: red;");
}
void MainWindow::AddLabelToFrame(QFrame* frame, const QString& labelText)
{
    QLabel* label = new QLabel(labelText, frame);
    label->setAlignment(Qt::AlignCenter);
    // label->setGeometry(0, 0, frame->width(), 20); // 将标签放置在 QFrame 的顶部
    // 获取QFrame和标签的大小
    int frameWidth = frame->width();
    int frameHeight = frame->height();
    int labelWidth = label->width()-15;
    int labelHeight = label->height()-15;

    // 计算标签应该放置的位置
    int x = (frameWidth - labelWidth) / 2;  // 水平方向居中
    int y = (frameHeight - labelHeight) / 2;  // 垂直方向居中

    // 设置标签的位置
    label->setGeometry(x, y, labelWidth, labelHeight);
}

//默认
void MainWindow::DefaultPattern()
{
    Lighting = ui->Lighting;  // 照明
    Lighting->setFixedSize(300, 300);
    Lighting->setStyleSheet("background-color: grey");

    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, [=](){
        // static bool isGrey = true;
        if( temp==false)
        {
            if (isGrey)
            {

                Lighting->setStyleSheet("background-color: red; border-radius: 150px;");
            }
            else
            {
                Lighting->setStyleSheet("background-color: grey; border-radius: 150px;");
            }
            isGrey = !isGrey;
        }
    });

    timer->start(500); // 设置闪烁间隔时间，单位为毫秒，这里设置为0.5秒
}

// void MainWindow::DefaultPattern()
// {
//     Lighting = ui->Lighting;  // 照明
//     Lighting->setStyleSheet("background-color: grey");


    // ambient = ui->ambient;     // 氛围灯
    // await = ui->await;         // 待机
    // baby = ui->baby;           // 宝宝风
    // dimming = ui->dimming;     // 调光
    // time = ui->time;           // 定时
    // gear1 = ui->gear1;
    // gear2 = ui->gear2;
    // gear3 = ui->gear3;
    // gear4 = ui->gear4;
    // gear5 = ui->gear5;
    // gear6 = ui->gear6;
    // gearstop = ui->stop;
    // reminder = ui->reminder;


    // QFrame* gears[] = {Lighting, ambient,
    //                    await, baby, dimming,
    //                    time, gear1, gear2,
    //                    gear3, gear4, gear5,
    //                    gear6, gearstop};
    // QString gearLabels[] = {"照明", "氛围灯", "待机", "宝宝风",
    //                         "调光", "定时", "1档位", "2档位",
    //                         "3档位", "4档位", "5档位", "6档位", "停止"};
    // const int numGears = sizeof(gears) / sizeof(gears[0]);

    // for (int i = 0; i < numGears; ++i)
    // {
    //     QFrame* currentGear = gears[i];
    //     const QString& currentLabel = gearLabels[i];

    //     if (i < 6 || i == 12) // 对前面六个控件设置相同样式和大小
    //     {
    //         currentGear->setFixedSize(GEAR_SIZE, GEAR_SIZE);
    //         currentGear->setStyleSheet("background-color: grey; border-radius: 42px;");
    //     }
    //     else
    //     {
    //         currentGear->setFixedSize(SECTOR_SIZE, SECTOR_SIZE); // 设置不同大小
    //         currentGear->setStyleSheet("background-color: grey; border-radius: 23px;"); // 设置不同样式
    //     }

    //     AddLabelToFrame(currentGear, currentLabel);
    // }
    // reminder->setStyleSheet("background-color: rgba(0, 0, 0, 0);");

// }
void MainWindow::OriginalCode()
{
    // 将十六进制字符串转换为无符号整数值
    unsigned int thirdSecondValue = thirdsecondByteArray.toUInt(nullptr, 16);
    unsigned int fourSecondValue = foursecondByteArray.toUInt(nullptr, 16);
    // qDebug() << "thirdSecondValue" << thirdSecondValue;
    // qDebug() << "fourSecondValue" << fourSecondValue;

    // 合成补码
    int complement = (thirdSecondValue << 8) | fourSecondValue;
    // qDebug() << "合成补码为：" << complement;

        // int finalValue;

    // 处理补码为负数的情况
    if (complement & 0x8000) {
        // 最高位为1，表示为负数
        // 补码取反加一
        int negComplement = (~complement + 1) & 0xFFFF; // 使用16位掩码
        finalValue = -negComplement;
    } else {
        // 最高位为0，表示为正数，原码即为补码本身
        finalValue = complement;
    }

    // qDebug() << "合成原码为：" << finalValue;
}

// bool MainWindow::CompareValues(QByteArray currentValue)
// {
//     static QByteArray previousValue; // 静态变量，保留上一次的数值
//     static QMutex mutex; // 互斥锁

//     mutex.lock(); // 上锁

//     bool result = false;

//     if (previousValue.isEmpty())
//     {
//         previousValue = currentValue;
//     }
//     else
//     {
//         if (previousValue == currentValue)
//         {
//             result = true;
//         }
//         previousValue = currentValue;
//     }

//     mutex.unlock(); // 解锁

//     return result;
// }
// if (lastData.startsWith(frameHeader) && lastData.endsWith(frameTail)&& (lastData.compare(secondByteArray) == 0) )

void MainWindow::EstimateData()
{
    int number = SaveRSSI.toInt();

    // QTimer *timer = new QTimer(this);
        // RightComp(Lighting);
    qDebug()<<"finalValue "<<finalValue;
    qDebug()<<"SaveRSSI "<<SaveRSSI;
     qDebug()<<"number "<<number;
    // qDebug()<<"static_cast<int>(SaveRSSI.toUInt(nullptr, 16)) "<<static_cast<int>(SaveRSSI.toUInt(nullptr, 16));
    if (finalValue >SaveRSSI.toInt() )
    {
        qDebug() << "进入判断1";
        qDebug()<<"temp "<<temp;
        if (secondByteArray == R_Lighting)
        {
            RightComp(Lighting);
            temp=true;
            timer->start(10000); // 开始定时，20秒后超时 20000
            qDebug() << "开始计数";
            ui->label->setText("倒计时10s");


        }
    }
    else
         qDebug() << "不满足rrsi";
}
            // qDebug() << "进入判断2"<<lastData.mid(2, 2)<<secondByteArray;
            // bool coptemp = CompareValues(fivesecondByteArray);
            // if (coptemp)
            // {
            //     qDebug() << "进入判断3 是同一个按键";
            //     comparisonCount++;
            //     secondByteComp = secondByteArray;
            //     AllcomparisonCount++;
            //     QThread::msleep(10); // 添加延时
            // }
            // else
            // {

            //     qDebug() << "判断3 ：再次按下";
            //     comparisonCount = 1;
            //     AllcomparisonCount = 1;
            //     QThread::msleep(2); // 添加延时

            // }

        // }
        // else
        // {

            // AllcomparisonCount=AllcomparisonCount/2;
            // comparisonCount=comparisonCount/2;
            // qDebug() << "进入判断4： 切换按键";
            // lastData = data;
            // secondByteComp = secondByteArray;
            // if (comparisonCount >= 3)
            // {
            //     ProcessFrame(yes);
            // }
            // else
            // {
            //     ProcessFrame(on);
            // }
            // qDebug() << "重置计数";
            // comparisonCount = 1;
            // AllcomparisonCount = 1;
            // QThread::msleep(2);
    //     }
    // }
    // else
    // {
    //     qDebug() << "不满足rrsi";
    // }

    // if (comparisonCount >= 3)
    // {
    //     ProcessFrame(yes);
    // }
    // else
    // {
    //     ProcessFrame(on);
    // }

    // qDebug() << "comparisonCount" << comparisonCount;
    // qDebug() << "AllcomparisonCount" << AllcomparisonCount;
// }
void MainWindow::ReceiveDataTest()
{
    ui->label->clear();
    if (!Within20s) {
        entertest = false;
        emit returnToReadData(); // 发送信号
    }

    if(data.isEmpty()) {
        // 如果 data 为 NULL，则不进行任何操作
    } else {
        if (data.startsWith(frameHeader) && data.endsWith(frameTail)) {
            // qDebug() << "data 以 frameHeader 开头并且以 frameTail 结尾";
            // qDebug() << "data"<<data;
            if (data.length() == 12 ) {
                secondByteArray = data.mid(2, 2); // 提取第二个字节的 QByteArray
                // qDebug() << "提取出的第二个 QByteArray 是：" << secondByteArray;
                thirdsecondByteArray = data.mid(4, 2); // 提取出的第三个 QByteArray 高八位
                // qDebug() << "高八位 是：" << thirdsecondByteArray;
                foursecondByteArray = data.mid(6, 2); // 提取出的第三个 QByteArray 低八位
                 // qDebug() << "低八位 是：" << foursecondByteArray;
                fivesecondByteArray = data.mid(8, 2);
                // qDebug() << "fivesecondByteArray 是：" << fivesecondByteArray;
                OriginalCode();
                EstimateData();
            }
            else {
                qDebug() << "接收到的数据有问题";
                // readData();

            }
        } else {
            qDebug() << "data 不符合条件";
        }
    }


}
// 判断后提示以为最多的为准进行展示
void MainWindow::ProcessFrame(int yeson)
{
    QMap<QByteArray, QFrame*> frameMap  = {
        {Onegear, gear1},
        {Twogear, gear2},
        {Threegear, gear3},
        {Fourgear, gear4},
        {Fivegear, gear5},
        {Sixgear, gear6},
        {Stopgear, gearstop},
        {Lightinggear, Lighting},
        {dimminggear,dimming},
        {Timegear, time},
        {Babygear, baby},
        {Ambientgear, ambient},
        {Awaitgear, await}
    };

    auto it = frameMap.find(secondByteComp);
    if (it != frameMap.end()) {
        QFrame* frame = it.value();
        if(yeson==yes)
        {
          if (frame == gear1 || frame == gear2 || frame == gear3 || frame == gear4 || frame == gear5 || frame == gear6)
                NumRightComp(frame);
          else RightComp(frame);

         }
        else if(yeson==on)
        {
            if (frame == gear1 || frame == gear2 || frame == gear3 || frame == gear4 || frame == gear5 || frame == gear6)
                NumErrorComp(frame);
            else ErrorComp(frame);
        }
    }
}
// void MainWindow::readData()
// {
//     static QByteArray buffer; // 缓冲区，保存接收到的字符
//     data = m_serial.readAll();
//     qDebug() << "接收到的数据：" << data;
//     // 去除data中的回车换行符
//     data = data.simplified();

//     // 去除startdata和data中的空格，统一格式
//     startdata = startdata.simplified().replace(" ", "");
//     data = data.replace(" ", "");

//     // std::string hexData = data.toStdString();
//     // std::string plainText = hexStringToPlainText(hexData);
//     // qDebug() << "接收到的plainText数据：" << plainText;
//     qDebug() << "接收到的buffer数据：" << buffer;
//     checkData(); // 调用新的函数进行数据判断和处理


// }


void MainWindow::readData()
{
    static QByteArray buffer; // 缓冲区，保存接收到的字符
    datatemp = m_serial.readAll();

    QString hexString = QString::fromLatin1(datatemp.toHex().toUpper()).remove("\\X");

    if (hexString.contains(frameHeader)) {
        buffer.clear(); // 清空缓冲区
    }

    buffer.append(datatemp);

    if (buffer.size() == 6 && hexString.contains(frameTail)) {
        // QThread::msleep(10); // 暂停5毫秒
        QString HexString = QString::fromLatin1(buffer.toHex().toUpper()).remove("\\X");
        QByteArray processedData = HexString.toLatin1();

        // data = processedData;
        // ui->label->setText(QString("判断的数据：%1").arg(processedData));
        buffer.clear(); // 清空缓冲区

        qDebug() << "processedData" << processedData;

        // 将processedData添加到列表中
        dataList.append(processedData);
    }
    // qDebug() << "dataList" << dataList;

    processNextData();
    // checkData();

}
void MainWindow::processNextData()
{
    qDebug() << "dataList.size()" << dataList.size();
    for (int i = currentIndex; i < dataList.size(); ++i) {
        QByteArray currentData = dataList.at(i);
        data = currentData;
        // checkData();
        ReceiveDataTest();
        qDebug() << "currentData " << i << ": " << currentData;
        if( i+1 == dataList.size())
            dataList.clear();
    }



    qDebug() << "dataList.clear()" << dataList;

}

void MainWindow::checkData()
{
    // static QMutex mutex;
    // ReceiveDataTest();
    // RightComp(Lighting);
    // mutex.lock();
    if (startdata == data) {
        ui->label->clear();
        // dataList.clear();
        comparisonCount = 1; // 重置计数
        AllcomparisonCount=1;
        DefaultPattern();
        // qDebug() << "data" << data;
        qDebug() << "启动测试命令";
         // QThread::msleep(20);
        entertest = true;
        // Within20s = !Within20s;
        Within20s = true ;
        timer->start(20000); // 开始定时，20秒后超时 20000
        ui->label->setText(("倒计时20s开始"));

    }
    else if (entertest && startdata != data) {
        ReceiveDataTest();
        // qDebug() << "entertest为真";
    }
    else {
        // 如果不满足上述条件，重新设置 Within20s 为 false
        Within20s = false;
    }
        // mutex.unlock();
}
void MainWindow::on_RSSI_returnPressed()
{
    qDebug() << "SaveRSSI" << SaveRSSI;
    if (!SaveRSSI.isEmpty()){
     ui->RSSI->setPlaceholderText(QString("RSSI值: %1").arg(SaveRSSI));
    }
    else {
        ui->RSSI->setPlaceholderText("RSSI值,默认为0");
    }

    // 获取输入的RSSI并更新SaveRSSI
    QString inputRSSI = ui->RSSI->text();
    if (!inputRSSI.isEmpty()) {
        SaveRSSI = inputRSSI;
    }

    qDebug() << "inputRSSI输入为" << SaveRSSI;
}


void MainWindow::on_comboBox_activated()
{
    QString portName = ui->comboBox->currentText(); // 获取选定的串口名称
    m_serial.close();
    OpenSerialPorts(portName); // 调用OpenSerialPorts函数，并传递选定的串口名称作为参数
    qDebug() << "portName" <<portName;
}

